JavaScript 'Using' Bayonoti va Istisnolar bilan ishlash: Resurslarni mustahkam tozalash

Zamonaviy JavaScript dasturlashda, resurslarni to'g'ri boshqarish va xatolarga ishlov berish ishonchli va samarali ilovalarni yaratish uchun juda muhimdir. using bayonoti deterministik resurslarni utilizatsiya qilish uchun kuchli mexanizmni taqdim etadi, an'anaviy try...catch...finally bloklarini to'ldiradi va yanada toza, saqlanishi oson kodga olib keladi. Ushbu blog postida using bayonotining murakkabliklari chuqurroq o'rganiladi, uning afzalliklari o'rganiladi va uni qo'llashni ko'rsatuvchi amaliy misollar keltiriladi.

JavaScriptda resurslarni boshqarishni tushunish

JavaScript, axlat yig'uvchi tili bo'lganligi sababli, endi erishib bo'lmaydigan ob'ektlar tomonidan egallab olingan xotirani avtomatik ravishda qayta oladi. Biroq, fayl tutqichlari, tarmoq ulanishlari va ma'lumotlar bazasi ulanishlari kabi ma'lum resurslar resurslarning tugashiga va potentsial ishlash muammolariga yo'l qo'ymaslik uchun aniq chiqarilishini talab qiladi. Ushbu resurslarni to'g'ri utilizatsiya qilmaslik xotira oqishiga, ilovaning beqarorligiga va oxir-oqibat foydalanuvchi tajribasining yomonlashishiga olib kelishi mumkin.

Resurslarni boshqarishning an'anaviy yondashuvlari ko'pincha try...catch...finally blokiga tayanadi. Ushbu yondashuv funktsional bo'lsa-da, u ko'p resurslar bilan ishlashda, ayniqsa, batafsil va murakkab bo'lishi mumkin. using bayonoti yanada ixcham va oqlangan yechimni taklif etadi.

'Using' bayonotini taqdim etish

using bayonoti, istisno tashlanganligidan qat'iy nazar, u e'lon qilingan kod bloki tugagandan so'ng resurs avtomatik ravishda utilizatsiya qilinishini ta'minlash orqali resurslarni boshqarishni soddalashtiradi. U deterministik resurslarni utilizatsiya qilishni ta'minlaydi, ya'ni resursning ma'lum vaqtda chiqarilishiga kafolat beriladi.

using bayonoti Symbol.dispose yoki Symbol.asyncDispose usullarini amalga oshiradigan ob'ektlar bilan ishlaydi. Ushbu usullar resursni chiqarish mantig'ini aniqlaydi.

Sintaksis

using bayonotining asosiy sintaksisi quyidagicha:

            using (resource) {
  // Resursdan foydalanadigan kod
}

            

              
                Copy
              
            
          

Bu yerda resource Symbol.dispose (sinxron utilizatsiya uchun) yoki Symbol.asyncDispose (asinxron utilizatsiya uchun) ni amalga oshiradigan ob'ektdir.

Symbol.dispose bilan sinxron resurslarni utilizatsiya qilish

Sinxron resurslarni utilizatsiya qilish uchun, ob'ekt Symbol.dispose usulini amalga oshirishi kerak. Ushbu usul using bloki tugagandan so'ng avtomatik ravishda chaqiriladi.

Misol: Maxsus resursni boshqarish

Keling, fayl yozuvchi vakili bo'lgan maxsus resursning oddiy misolini yarataylik. Ushbu resurs, kerak bo'lmaganda faylni yopish uchun Symbol.dispose usulini amalga oshiradi.

            class FileWriter {
  constructor(filePath) {
    this.filePath = filePath;
    this.fileHandle = this.openFile(filePath); // Faylni ochishni taqlid qilish
    console.log(`Fayl ochildi: ${filePath}`);
  }

  openFile(filePath) {
    // Faylni ochishni taqlid qilish
    console.log(`Faylni ochishni taqlid qilish: ${filePath}`);
    return {}; // Fayl tutqichi uchun joy egallovchi ob'ektni qaytarish
  }

  writeFile(data) {
    // Faylga yozishni taqlid qilish
    console.log(`Faylga ma'lumot yozish: ${this.filePath}`);
  }

  [Symbol.dispose]() {
    // Faylni yopishni taqlid qilish
    console.log(`Faylni yopish: ${this.filePath}`);
    // Haqiqiy senariyda, siz fayl tutqichini bu yerda yopasiz.
  }
}

// 'Using' bayonati bilan FileWriter dan foydalanish
using (const writer = new FileWriter('example.txt')) {
  writer.writeFile('Salom, dunyo!');
  // 'Using' bloki tugagandan so'ng fayl avtomatik ravishda yopiladi
}

console.log('Fayl yozuvchisi utilizatsiya qilindi.');

            

              
                Copy
              
            
          

Ushbu misolda, FileWriter klassida faylni yopishni taqlid qiladigan Symbol.dispose usuli mavjud. using bloki tugagandan so'ng, Symbol.dispose usuli avtomatik ravishda chaqiriladi, bu blok ichida istisno yuz berganda ham fayl yopilishini ta'minlaydi.

Symbol.asyncDispose bilan asinxron resurslarni utilizatsiya qilish

Asinxron resurslarni utilizatsiya qilish uchun, ob'ekt Symbol.asyncDispose usulini amalga oshirishi kerak. Ushbu usul using bloki tugagandan so'ng asinxron tarzda chaqiriladi. Bu asinxron tozalash operatsiyalarini bajaradigan resurslar, masalan, tarmoq ulanishlarini yopish yoki ma'lumotlar bazasi ulanishlarini chiqarish uchun juda muhimdir.

Misol: Asinxron resursni boshqarish

Keling, ma'lumotlar bazasi ulanishini ifodalovchi asinxron resursning misolini yarataylik. Ushbu resurs, ulanishni asinxron tarzda yopish uchun Symbol.asyncDispose usulini amalga oshiradi.

            class DatabaseConnection {
  constructor(connectionString) {
    this.connectionString = connectionString;
    this.connection = this.connect(connectionString); // Ma'lumotlar bazasiga ulanishni taqlid qilish
    console.log(`Ma'lumotlar bazasi ulanishi o'rnatildi: ${connectionString}`);
  }

  async connect(connectionString) {
    // Ma'lumotlar bazasiga asinxron ulanishni taqlid qilish
    console.log(`Asinxron ma'lumotlar bazasi ulanishini taqlid qilish: ${connectionString}`);
    return {}; // Ma'lumotlar bazasi ulanishi uchun joy egallovchi ob'ektni qaytarish
  }

  async query(sql) {
    // So'rovni asinxron tarzda bajarishni taqlid qilish
    console.log(`So'rovni bajarish: ${sql}`);
    return []; // Joy egallovchi natijani qaytarish
  }

  async [Symbol.asyncDispose]() {
    // Ma'lumotlar bazasi ulanishini asinxron tarzda yopishni taqlid qilish
    console.log(`Ma'lumotlar bazasi ulanishini yopish: ${this.connectionString}`);
    // Haqiqiy senariyda, siz ma'lumotlar bazasi ulanishini bu yerda asinxron tarzda yopasiz.
    await new Promise(resolve => setTimeout(resolve, 500)); // Asinxron operatsiyani taqlid qilish
    console.log(`Ma'lumotlar bazasi ulanishi yopildi: ${this.connectionString}`);
  }
}

// 'Using' bayonati bilan DatabaseConnection dan foydalanish
async function main() {
  await using (const connection = new DatabaseConnection('mongodb://localhost:27017')) {
    await connection.query('SELECT * FROM users');
    // Ma'lumotlar bazasi ulanishi 'using' bloki tugagandan so'ng avtomatik ravishda asinxron tarzda yopiladi
  }

  console.log('Ma'lumotlar bazasi ulanishi utilizatsiya qilindi.');
}

main();

            

              
                Copy
              
            
          

Ushbu misolda, DatabaseConnection klassida ma'lumotlar bazasi ulanishini asinxron tarzda yopishni taqlid qiladigan Symbol.asyncDispose usuli mavjud. using bayonoti, asinxron utilizatsiya operatsiyasi dastur davom etishidan oldin tugashini ta'minlash uchun await kalit so'zi bilan ishlatiladi. Bu resurslarning oqib ketishini oldini olish va ma'lumotlar bazasi ulanishini to'g'ri yopilishini ta'minlash uchun juda muhimdir.

'Using' bayonatidan foydalanishning afzalliklari

• Deterministik resurslarni utilizatsiya qilish: Resurslar kerak bo'lmaganda chiqarilishiga kafolat beradi, resurslarning oqib ketishini oldini oladi.
• Soddalashtirilgan kod: An'anaviy try...catch...finally bloklariga nisbatan resurslarni boshqarish uchun zarur bo'lgan shablon kodini kamaytiradi.
• Yaxshilangan o'qilishi: Kodni resursdan foydalanish doirasini aniq ko'rsatib, yanada o'qiladigan va tushunarli qiladi.
• Istisno xavfsizligi: using blokida istisno yuz bersa ham resurslarning chiqarilishini ta'minlaydi.
• Asinxron qo'llab-quvvatlash: Zamonaviy JavaScript ilovalari uchun zarur bo'lgan Symbol.asyncDispose bilan asinxron resurslarni utilizatsiya qilishni ta'minlaydi.

'Using' ni 'Try...Catch' bilan birlashtirish

using bayonoti, resursdan foydalanish paytida yuzaga kelishi mumkin bo'lgan istisnolarni boshqarish uchun try...catch bloklari bilan samarali birlashtirilishi mumkin. using bayonoti, istisno tashlanganligidan qat'iy nazar, resursning utilizatsiya qilinishiga kafolat beradi.

Misol: 'Using' bilan istisnolarga ishlov berish

            class Resource {
  constructor() {
    console.log('Resurs olingan.');
  }

  use() {
    // Potentsial xatoni taqlid qilish
    const random = Math.random();
    if (random < 0.5) {
      throw new Error('Resursdan foydalanishda taqlid qilingan xato.');
    }
    console.log('Resurs muvaffaqiyatli ishlatildi.');
  }

  [Symbol.dispose]() {
    console.log('Resurs utilizatsiya qilingan.');
  }
}

function processResource() {
  try {
    using (const resource = new Resource()) {
      resource.use();
    }
  } catch (error) {
    console.error(`Xatolik yuz berdi: ${error.message}`);
  }
  console.log('Resursni qayta ishlash yakunlandi.');
}

processResource();

            

              
                Copy
              
            
          

Ushbu misolda, try...catch bloki resource.use() usuli tomonidan tashlanishi mumkin bo'lgan har qanday istisnolarni ushlaydi. using bayonoti, istisno ushlanganligidan qat'iy nazar resursning utilizatsiya qilinishini ta'minlaydi.

'Using' bilan bir nechta resurslar

using bayonoti bir vaqtning o'zida bir nechta resurslarni boshqarish uchun ishlatilishi mumkin. Bu bir nechta resurslarni using blokida, nuqtali vergullar bilan ajratilgan holda e'lon qilish orqali amalga oshirilishi mumkin.

Misol: Bir nechta resurslarni boshqarish

            class Resource1 {
  constructor(name) {
    this.name = name;
    console.log(`${name}: Resurs olingan.`);
  }

  [Symbol.dispose]() {
    console.log(`${this.name}: Resurs utilizatsiya qilingan.`);
  }
}

class Resource2 {
  constructor(name) {
    this.name = name;
    console.log(`${name}: Resurs olingan.`);
  }

  [Symbol.dispose]() {
    console.log(`${this.name}: Resurs utilizatsiya qilingan.`);
  }
}

using (const resource1 = new Resource1('Resurs 1'); const resource2 = new Resource2('Resurs 2')) {
  console.log('Ikkala resursdan ham foydalanish.');
}

console.log('Resursni qayta ishlash yakunlandi.');

            

              
                Copy
              
            
          

Ushbu misolda, resource1 va resource2 bo'lgan ikkita resurs bir xil using blokida boshqariladi. Blok tugagandan so'ng ikkala resurs ham utilizatsiya qilinadi.

'Using' bayonotidan foydalanishning eng yaxshi amaliyotlari

• 'Symbol.dispose' yoki 'Symbol.asyncDispose' ni amalga oshirish: Resurs ob'ektlaringiz tegishli utilizatsiya usulini amalga oshirganligiga ishonch hosil qiling.
• Istisnolarga ishlov berish: Resursdan foydalanish paytida yuzaga kelishi mumkin bo'lgan istisnolarga ishlov berish uchun try...catch bloklaridan foydalaning.
• Resurslarni to'g'ri tartibda utilizatsiya qilish: Agar resurslar bog'liqlikka ega bo'lsa, ularni olingan tartibiga teskari tartibda utilizatsiya qiling.
• Uzoq umr ko'radigan resurslardan saqlaning: Resurs oqishi xavfini kamaytirish uchun resurslarni iloji boricha kichik doirada saqlang.
• Asinxron operatsiyalar uchun asinxron utilizatsiyadan foydalaning: Asinxron tozalash operatsiyalarini talab qiladigan resurslar uchun Symbol.asyncDispose dan foydalaning.

Brauzer va JavaScript dvigateli qo'llab-quvvatlashi

using bayonoti JavaScriptda nisbatan yangi xususiyat bo'lib, ECMAScript 2024 yoki undan keyingi versiyalarini qo'llab-quvvatlaydigan zamonaviy JavaScript dvigatelini talab qiladi. Ko'pgina zamonaviy brauzerlar va Node.js versiyalari ushbu xususiyatni qo'llab-quvvatlaydi, ammo maqsadli muhitingiz uchun mosligini tekshirish juda muhimdir. Agar siz eski muhitlarni qo'llab-quvvatlashingiz kerak bo'lsa, kodni eski JavaScript versiyasiga o'tkazish uchun Babel kabi transpilyatordan foydalaning yoki try...finally kabi muqobil resurslarni boshqarish usullaridan foydalaning.

Foydalanish holatlari va real dunyo ilovalari

using bayonoti deterministik resurslarni boshqarish juda muhim bo'lgan turli xil senariylarda qo'llaniladi.

• Fayllar bilan ishlash: Ma'lumotlarning buzilishi va resurslarning tugashini oldini olib, fayllarning ishlatilgandan so'ng to'g'ri yopilishini ta'minlash.
• Ma'lumotlar bazasi ulanishlari: Ulanish havzasi tugashining va ishlash muammolarining oldini olish uchun ma'lumotlar bazasi ulanishlarini zudlik bilan chiqarish.
• Tarmoq ulanishlari: Resurslarning oqib ketishini oldini olish va tarmoqning ishlashini yaxshilash uchun tarmoq rozetkalari va oqimlarini yopish.
• WebSockets: Ishonchli aloqani ta'minlash va resurslarning tugashini oldini olish uchun WebSocket ulanishlarini to'g'ri yopish.
• Grafika resurslari: Grafikaga talab yuqori bo'lgan ilovalarda xotira oqishini oldini olish uchun grafika resurslarini, masalan, teksturalar va buferlarni chiqarish.
• Uskuna resurslari: Ziddiyatlarning oldini olish va to'g'ri ishlashni ta'minlash uchun datchiklar va aktuatorlar kabi uskunalar resurslariga kirishni boshqarish.

'Using' bayonatiga alternativa

using bayonoti resurslarni boshqarishning qulay va samarali usulini taqdim etsa-da, using bayonati mavjud bo'lmagan yoki mos bo'lmagan vaziyatlarda ishlatilishi mumkin bo'lgan muqobil yondashuvlar mavjud.

• Try...Finally: Resurslarning chiqarilishini ta'minlash uchun an'anaviy try...finally blokidan foydalanish mumkin, ammo u ko'proq shablon kodini talab qiladi.
• Resurs o'rash vositalari: O'z konstruktorida va destruktorida resurs olish va utilizatsiya qilishni boshqaradigan maxsus resurs o'rash ob'ektlarini yaratish.
• Resurslarni qo'lda boshqarish: Kod blokining oxirida resurslarni qo'lda chiqarish, ammo bu yondashuv xatolarga moyil bo'lib, agar ehtiyotkorlik bilan qilinmasa, resurslarning oqib ketishiga olib kelishi mumkin.

Xulosa

JavaScript using bayonoti deterministik resurslarni boshqarish va istisnolarga ishlov berishni ta'minlash uchun kuchli vositadir. Resurslarni chiqarishning ixcham va oqlangan usulini taqdim etish orqali, u xotira oqishini oldini olishga, ilovaning barqarorligini oshirishga va yanada toza, saqlash oson kodga olib keladi. using bayonotini, uning sinxron (Symbol.dispose) va asinxron (Symbol.asyncDispose) variantlari bilan birga tushunish va undan foydalanish mustahkam va samarali JavaScript ilovalarini yaratish uchun juda muhimdir. JavaScript rivojlanishda davom etar ekan, ushbu resurslarni boshqarish texnikalarini o'zlashtirish dunyo bo'ylab dasturchilar uchun tobora muhim bo'lib boradi.

JavaScriptni ishlab chiqish amaliyotingizni yaxshilash va global auditoriya uchun yanada ishonchli va samarali ilovalarni yaratish uchun using bayonotini qabul qiling.